package com.atguigu.tingshu.album.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.atguigu.tingshu.album.mapper.*;
import com.atguigu.tingshu.album.service.BaseCategoryService;
import com.atguigu.tingshu.common.cache.TsCache;
import com.atguigu.tingshu.model.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@SuppressWarnings({"all"})
public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, BaseCategory1> implements BaseCategoryService {

	@Autowired
	private BaseCategory1Mapper baseCategory1Mapper;

	@Autowired
	private BaseCategory2Mapper baseCategory2Mapper;

	@Autowired
	private BaseCategory3Mapper baseCategory3Mapper;


	@Autowired
	private BaseCategoryViewMapper baseCategoryViewMapper;

	@Autowired
	private BaseAttributeMapper baseAttributeMapper;

	/**
	 * @author WeakMoon
	 * @date 2025/02/17 16:42:54
	 * 获取所有分类信息
	 */
	@Override
	public List<JSONObject> getBaseCategoryList() {
		//创建一个空的JSON对象列表，用于存储最终的分类信息
		List<JSONObject> list = new ArrayList<>();

		//获取所有分类数据
		List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(null);

		//创建一个Map集合
		Map<Long, List<BaseCategoryView>> categroyMap = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));

		//循环遍历集合
		Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = categroyMap.entrySet().iterator();
		while (iterator.hasNext()){
			//获取元素
			Map.Entry<Long, List<BaseCategoryView>> entry = iterator.next();

			//获取一级分类id
			Long category1Id = entry.getKey();

			//获取一级分类名称
			String category1Name = entry.getValue().get(0).getCategory1Name();

			//构建数据
			JSONObject category1 = new JSONObject();
			category1.put("categoryId",category1Id);
			category1.put("categoryName",category1Name);

			//获取二级分类数据集合
			Map<Long, List<BaseCategoryView>> category2Map = entry.getValue().stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));

			Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator1 = category2Map.entrySet().iterator();

			//创建一个集合
			ArrayList<JSONObject> category2Child = new ArrayList<>();

			while (iterator1.hasNext()){
				//获取元素
				Map.Entry<Long, List<BaseCategoryView>> entry1 = iterator1.next();

				//获取二级分类id
				Long category2Id = entry1.getKey();

				//获取二级分类名称
				String category2Name = entry1.getValue().get(0).getCategory2Name();

				//构建二级对象
				JSONObject category2 = new JSONObject();
				category2.put("categoryId",category2Id);
				category2.put("categoryName",category2Name);

				//获取三级分类数据集合
				List<JSONObject> category3Child = entry1.getValue().stream().map(baseCategoryView -> {
					//创建三级分类对象
					JSONObject category3 = new JSONObject();
					category3.put("categoryId", baseCategoryView.getCategory3Id());
					category3.put("categoryName", baseCategoryView.getCategory3Name());

					// 返回数据
					return category3;
				}).collect(Collectors.toList());
				category2.put("categoryChild",category3Child);

				// 将所有的二级分类对象添加到集合中
				category2Child.add(category2);
			}
			// 将一级分类数据添加到集合中
			category1.put("categoryChild",category2Child);
			list.add(category1);
		}
		// 返回数据
		return list;
	}

	/**
	 * @author WeakMoon
	 * @date 2025/02/18 21:22:27
	 * 根据一级分类id获取标签数据
	 */
	@Override
	public List<BaseAttribute> findAttribute(Long category1Id) {
		//	调用mapper层
		return baseAttributeMapper.selectAttribute(category1Id);
	}

	/**
	 * @author WeakMoon
	 * @date 2025/02/25 20:02:22
	 * 根据三级分类Id 获取到分类数据
	 */
	@Override
	@TsCache(prefix = "category:")
	public BaseCategoryView getBaseCategoryView(Long category3Id) {
		// 通过三级分类ID查询并返回分类视图对象
		return baseCategoryViewMapper.selectById(category3Id);
	}

	/**
	 * @author WeakMoon
	 * @date 2025/02/27 15:26:27
	 * 根据一级分类id获取分类数据
	 */
	@Override
	public JSONObject getBaseCategoryList(Long category1Id) {
	    // 创建一个JSONObject对象用于存储一级分类数据
	    JSONObject category1 = new JSONObject();

	    // 将一级分类id存入category1对象中
	    category1.put("categoryId",category1Id);

	    // 通过Mapper查询与一级分类id相关联的所有分类视图数据
	    List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(new LambdaQueryWrapper<BaseCategoryView>().eq(BaseCategoryView::getCategory1Id, category1Id));

		// 将一级分类名称存入category1对象中
	    category1.put("categoryName",baseCategoryViewList.get(0).getCategory1Name());

	    // 使用Stream API按二级分类id对查询结果进行分组
	    Map<Long,List<BaseCategoryView>> category2Map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));

		// 创建一个迭代器用于遍历二级分类的Map
	    Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = category2Map.entrySet().iterator();

		// 创建一个ArrayList用于存储二级分类及其子分类的数据
	    ArrayList<JSONObject> categoryChild2List = new ArrayList<>();

		// 遍历二级分类的Map
	    while (iterator.hasNext()){
			// 获取当前二级分类及其对应的分类视图列表
	        Map.Entry<Long, List<BaseCategoryView>> entry = iterator.next();
	        Long category2Id = entry.getKey();
	        List<BaseCategoryView> categoryViewList = entry.getValue();

			// 创建一个JSONObject对象用于存储二级分类数据
	        JSONObject category2 = new JSONObject();

			// 将二级分类id存入category2对象中
	        category2.put("categoryId",category2Id);

			// 将二级分类名称存入category2对象中
	        category2.put("categoryName",categoryViewList.get(0).getCategory2Name());

			// 使用Stream API将三级分类数据转换为JSONObject对象并收集到一个列表中
	        List<JSONObject> list = categoryViewList.stream().map(categroyView -> {
	            JSONObject category3 = new JSONObject();

				// 将三级分类id存入category3对象中
	            category3.put("categoryId", categroyView.getCategory3Id());

				// 将三级分类名称存入category3对象中
	            category3.put("categoryName", categroyView.getCategory3Name());
	            return category3;
	        }).collect(Collectors.toList());

			// 将三级分类列表存入二级分类对象中
	        category2.put("categoryChild",list);

			// 将二级分类对象添加到二级分类列表中
	        categoryChild2List.add(category2);
	    }
	    // 将二级分类列表存入一级分类对象中
	    category1.put("categoryChild",categoryChild2List);

	    // 返回一级分类对象
	    return category1;
	}

	/**
	 * @author WeakMoon
	 * @date 2025/02/28 16:01:31
	 * 根据一级分类id查询三级分类数据
	 */
	@Override
	public List<BaseCategory3> findTopBaseCategory3(Long category1Id) {
	    // 根据一级分类ID查询所有的二级分类ID
	    List<Long> category2IdList = baseCategory2Mapper.selectList(new LambdaQueryWrapper<BaseCategory2>().eq(BaseCategory2::getCategory1Id, category1Id)).stream().map(BaseCategory2::getId).collect(Collectors.toList());

	    // 根据二级分类ID查询顶级的三级分类数据，每个二级分类对应最多7个三级分类
	    List<BaseCategory3> baseCategory3List = baseCategory3Mapper.selectList(new LambdaQueryWrapper<BaseCategory3>().in(BaseCategory3::getCategory2Id, category2IdList).eq(BaseCategory3::getIsTop, 1).last("limit 7"));

	    // 返回查询到的三级分类列表
	    return baseCategory3List;
	}
}
